import axios from 'axios' // 引入axios
import { Toast } from 'vant'
import { router } from '@/router/index.js'
// import QS from 'QS'; //post 参数序列化

//环境切换
if (process.env.NODE_ENV == 'development') {
  axios.defaults.baseURL = '192.168.0.111:8000' //基础url + api.js中的 url
} else if (process.env.NODE_ENV == 'debug') {
  axios.defaults.baseURL = '192.168.0.111:8000'
} else if (process.env.NODE_ENV == 'production') {
  axios.defaults.baseURL = '192.168.0.111:8000'
}
// 请求超时 请求头
axios.defaults.timeout = 1000 * 10
axios.defaults.headers.post['Content-Type'] = 'application/x-www-form-urlencoded;charset=UTF-8'

// 请求拦截器
axios.interceptors.request.use(
  config => {
    // 每次发送请求之前判断是否存在token，如果存在，则统一在http请求的header都加上token，不用每次请求都手动添加了
    // 即使本地存在token，也有可能token是过期的，所以在响应拦截器中要对返回状态进行判断
    const token = window.localStorage['token'] //token存储在浏览器
    token && (config.headers.Authorization = token)
    return config
  },
  error => {
    return Promise.error(error)
  }
)

// 响应拦截器
axios.interceptors.response.use(
  response => {
    if (response.status === 200) {
      switch (response.data.code) {
        case 3001:
          Toast({
            message: '请登录后操作',
            duration: 2000,
            forbidClick: true
          })
          // setTimeout(function() {
          //   router.replace({
          //     path: '/login', // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
          //     query: {
          //       redirect: router.currentRoute.fullPath
          //     }
          //   })
          // }, 2000)
          return Promise.reject(response)
        case 301:
          Toast({
            message: '还未登录，请先登录',
            duration: 1000,
            forbidClick: true
          })
          // router.replace({
          //   path: '/login', // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
          //   query: {
          //     redirect: router.currentRoute.fullPath
          //   }
          // })
          return Promise.reject(response)
        case 302:
          Toast({
            message: '登录已过期，请重新登录',
            duration: 1000,
            forbidClick: true
          })
          localStorage.removeItem('ud')
          localStorage.removeItem('un')
          localStorage.removeItem('up')
          localStorage.removeItem('uh')
          localStorage.removeItem('us')
          localStorage.removeItem('token')
          // router.replace({
          //   path: '/login', // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
          //   query: {
          //     redirect: router.currentRoute.fullPath
          //   }
          // })
          return Promise.reject(response)
        default:
          return Promise.resolve(response)
      }
    } else {
      return Promise.reject(response)
    }
  },
  // 服务器状态码不是200的情况
  error => {
    window.console.log(error)

    if (error.response.status) {
      switch (error.response.status) {
        // 401: 未登录
        case 401:
          // router.replace({
          //   path: '/login', // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
          //   query: {
          //     redirect: router.currentRoute.fullPath
          //   }
          // })
          break
        case 403:
          Toast({
            message: '登录过期，请重新登录',
            duration: 1000,
            forbidClick: true
          })
          // 清除token
          localStorage.removeItem('ud')
          localStorage.removeItem('un')
          localStorage.removeItem('up')
          localStorage.removeItem('uh')
          localStorage.removeItem('us')
          localStorage.removeItem('token')
          // setTimeout(() => {
          //   router.replace({
          //     path: '/login', // 跳转登录页面，并将要浏览的页面fullPath传过去，登录成功后跳转需要访问的页面
          //     query: {
          //       redirect: router.currentRoute.fullPath
          //     }
          //   })
          // }, 1000)
          break
        // 404请求不存在
        case 404:
          Toast({
            message: '地址不存在',
            duration: 1500,
            forbidClick: true
          })
          break
        // 其他错误，直接抛出错误提示
        default:
          Toast({
            message: error.response.data.message,
            duration: 1500,
            forbidClick: true
          })
      }
      return Promise.reject(error.response)
    }
  }
)

export function getwxpcAppId() {
  if (process.env.NODE_ENV == 'development') {
    return '微信appid'
  } else if (process.env.NODE_ENV == 'debug') {
    return '微信appid'
  } else if (process.env.NODE_ENV == 'production') {
    return '微信appid'
  }
}
export function getwxAppId() {
  if (process.env.NODE_ENV == 'development') {
    return '微信appid'
  } else if (process.env.NODE_ENV == 'debug') {
    return '微信appid'
  } else if (process.env.NODE_ENV == 'production') {
    return '微信appid'
  }
}

export let headers = {
  Accept: 'application/json',
  'Content-Type': 'application/json',
  ACCESS_TOKEN: localStorage.token
}
export let fileHeaders = {
  'Content-Type': 'multipart/form-data',
  ACCESS_TOKEN: localStorage.token
}

export function refenceHeaders() {
  headers = {
    Accept: 'application/json',
    'Content-Type': 'application/json',
    ACCESS_TOKEN: localStorage.token
  }
  fileHeaders = {
    Accept: 'application/json',
    'Content-Type': 'multipart/form-data',
    ACCESS_TOKEN: localStorage.token
  }
}

/**
 * get方法，对应get请求
 * @param {String} url [请求的url地址]
 * @param {Object} params [请求时携带的参数]
 */
export function getWXUserInfo(access_token, openid) {
  return new Promise((resolve, reject) => {
    axios
      .get(
        'https://api.weixin.qq.com/sns/userinfo?access_token=' + access_token + '&openid=' + openid + '&lang=zh_CN',
        { headers }
      )
      .then(res => {
        resolve(res.data)
      })
      .catch(err => {
        reject(err.data)
      })
  })
}
/**
 * 上传文件
 * @param {String} url [请求的url地址]
 * @param {Object} file [文件]
 */
export function uploadFile(url, file) {
  return new Promise((resolve, reject) => {
    const data = new FormData()
    data.append('file', file)
    axios
      .post(url, data, {
        fileHeaders
      })
      .then(res => {
        resolve(res.data)
      })
      .catch(err => {
        reject(err.data)
      })
  })
}
/**
 * get方法，对应get请求
 * @param {String} url [请求的url地址]
 * @param {Object} params [请求时携带的参数]
 */
export function get(url, params) {
  return new Promise((resolve, reject) => {
    axios
      .get(url, {
        params,
        headers
      })
      .then(res => {
        resolve(res.data)
      })
      .catch(err => {
        reject(err.data)
      })
  })
}
/**
 * post方法，对应post请求
 * @param {String} url [请求的url地址]
 * @param {Object} params [请求时携带的参数]
 */
export function post(url, params) {
  return new Promise((resolve, reject) => {
    axios
      .post(url, params, { headers })
      .then(res => {
        resolve(res.data)
      })
      .catch(err => {
        reject(err.data)
      })
  })
}
/**
 * 封装patch请求
 * @param url
 * @param params
 * @returns {Promise}
 */
export function patch(url, params) {
  return new Promise((resolve, reject) => {
    axios.patch(url, params, { headers }).then(
      response => {
        resolve(response.data)
      },
      err => {
        reject(err)
      }
    )
  })
}

/**
 * put 请求
 * @param  url
 * @param  params
 */
export function put(url, params) {
  return new Promise((resolve, reject) => {
    axios.put(url, params, { headers }).then(
      response => {
        resolve(response.data)
      },
      err => {
        reject(err)
      }
    )
  })
}
